

export const verificationEvent = (rules_data) => {
  /**
   *@param {  type  Object | String  } rules_data  校验的对象   单个 字段验证
   */
  //  手机正则
  //  手机号号码数
  //  手机号是否符合格式
  let phone_regexp = /^1[3-9][0-9]{9}$/;
  //    手机号长度
  let length_regexp = /^\d{11}$/;
  //  邮箱格式
  //  邮箱 暂支持qq 邮箱的验证
  let email_regexp = /^\d+@qq.com$/;
  //

  /**
   * 需要 验证的字段 rules
   */
  //  验证规则函数
  /**
   * @param { type Function (rules_arr:Array<{propName:any} | stirng?>) => boolearn } validationDate_Fnc
   * @returns Boolean
   */
  const status_Fnc = (str, v_status) => {
    let modile_obj = {
      status: v_status,
      message: str,
      message_Fnc: function (str) {
        this.message = str;
        return modile_obj;
      },
    };
    return modile_obj;
  };
  //  手机号校验
  /**
   * interfce mobile_obj   = {
   *  status:boolean,
   *  message:string  | null,
   *  message_Fnc: (str) =>  mobile_obj
   * }
   * @param { type String } moblie_name   校验的字段名  || 校验的字段
   * @returns { type  Object } mobile_obj   验证对象
   */
  const mobile_Fnc = (moblie_name) => {
    //  需要验证的字段
    let str = String(rules_data[moblie_name]);
    if (!str.match(length_regexp)) {
      return status_Fnc("请输入11位手机号", false);
    } else if (!str.match(phone_regexp)) {
      return status_Fnc("手机格式不正确", false);
    } else {
      return status_Fnc(null, true);
    }
  };

  //  邮箱 校验
  const email_Fnc = (moblie_name) => {
    let str = String(rules_data[moblie_name]);
    if (!str.match(email_regexp)) {
      return status_Fnc("请输入正确的邮箱格式", false);
    } else {
      return status_Fnc("", true);
    }
  };

  // 全部字段 验证
  let validationDate_Fnc = (rules_arr, success_fnc, fail_fnc) => {
    // console.log( rules_arr)
    /**
     * @param { type String } name   要验证的字段名
     * @param { type  Boolean} require  是否为必填项
     * @param { type Regexp  }   regexp   正则
     * @param { type Number }  len   规定的字符
     * @param  { type  Number | string } min 最小值
     * @param {  type Number | string } max 最大值
     * @param {  type  String } enum  指定的值
     * 规定的字段
     * */
    //  数据源 key 值
    console.log(rules_arr)
    if (!tool_Fnc().is_array(rules_arr)) {
      console.log(`validationData第一字段应填写数组`);
      return;
    }
    const v_data = Object.keys(rules_data);
    //  全部信息数组
    let all_array = [];
    // 提示 字段名
    let prompt_nameArr = [];
    // 验证函数
    const vali_Fnc = (v_obj, i) => {
      //  返回的信息对象
      let vali_obj = {};
      //  数据源 中是否有要验证的字段
      let v_index = v_data.includes(v_obj.name);
      //  要验证的值 value
      let v_value = rules_data[v_obj.name];
      console.log(v_value);
      //  要验证的key 值
      let key_name = v_obj.name;
      //  返回的错误信息数组
      let v_array = [];
      //  错误提示
      let v_message = v_obj.message || "";

      //  正则  string ->  转 正则 
      function regFnc(reg_str, call) {
        //正则处理  reg_str
        //截取 ->  reg_str
        // new_Str 转为正则
        let new_Str = new RegExp(reg_str.substring(1, reg_str.length - 1));
        if (tool_Fnc().is_regexp(new_Str)) {
          if (!new_Str.test(v_value)) {
            return {
              name: key_name,
              status: false,
              message: v_message || `${key_name}正则不通过`,
            };
          }
        } else {
          return {
            status: false,
            message: "正则格式错误",
          };
        }
      }
      //  验证1的字段名
      function recursion_Fnc(v_keys) {
        //   错误信息 or  正确信息
        // 没传require 是否是必填项 default true
        switch (v_keys) {
          case "require":
            if (v_value === "") {
              vali_obj = {
                name: key_name,
                status: false,
                message: v_message || `${key_name}是必填项目`,
              };
              v_array.push(vali_obj);
            }
            break;
          case "regexp":
            vali_obj = regFnc(v_obj[v_keys]) ?? false;
            console.log(vali_obj);
            if (vali_obj) {
              v_array.push(vali_obj);
            }
            break;
          case "min":
            //  字符在 min ~ max 之间
            let m_min = "min" in v_obj;
            var m_regexp = m_min
              ? new RegExp(`^.{${v_obj["min"]},${v_obj[v_keys]}}$`)
              : new RegExp(`^.{${v_obj[v_keys]}}$`);
            if (!m_regexp.test(v_value)) {
              vali_obj = {
                name: key_name,
                status: false,
                message: v_message || `${key_name}的最小长度为${v_obj[v_keys]}`,
              };
              v_array.push(vali_obj);
            }
            // console.log('最小值');
            break;
          case "max":
            //  字符在 min ~ max 之间
            let m_max = "max" in v_obj;
            var m_regexp = m_max
              ? new RegExp(`^.{${v_obj[v_keys]},${v_obj["max"]}}$`)
              : new RegExp(`^.{${v_obj[v_keys]}}$`);
            if (!m_regexp.test(v_value)) {
              vali_obj = {
                name: key_name,
                status: false,
                message: v_message || `${key_name}的最大长度为${v_obj[v_keys]}`,
              };
              v_array.push(vali_obj);
            }
            // console.log('最大值');
            break;
          case "len":
            if (!(v_value.length == v_obj[v_keys])) {
              vali_obj = {
                name: key_name,
                status: false,
                message: v_message || `${key_name}为${v_obj[v_keys]}个字符`,
              };
              v_array.push(vali_obj);
            }
            // console.log('长度符合');
            break;
          case "enum":
            if (v_value !== v_obj[v_keys]) {
              vali_obj = {
                name: key_name,
                status: false,
                message: v_message || `${key_name}不为指定的字符`,
              };
              v_array.push(vali_obj);
            }
            break;
          default:
            break;
        }
      }
      if (!v_obj.name) {
        //  如果,没有名字
        //  自定义名字
        let v_name = `字段${i + 1}name值为填写`;
        prompt_nameArr.push(v_name);
      } else {
        // 循环
        for (let key in v_obj) {
          recursion_Fnc(key);
        }
      }
      all_array.push(v_array);
    };
    /**
     * @param { type Array<object> } rules_arr  要验证的字段
     */
    for (let i = 0; i < rules_arr.length; i++) {
      vali_Fnc(rules_arr[i], i);
    }
    /**
     * @param { type Array<Object> } clone_array 错误的全部信息  rules定义
     * @param { type Boolean } all_status  验证的状态
     */
    let clone_array = all_array.length ? all_array.flat() : [];
    let all_status = clone_array.every((item) => item.status);
    all_status
      ? success_fnc({
          status: true,
          s_data: null,
          clone_array,
          prompt_nameArr: prompt_nameArr.length ? prompt_nameArr : null,
        })
      : fail_fnc({
          status: false,
          s_data: clone_array,
          clone_array,
          prompt_nameArr: prompt_nameArr.length ? prompt_nameArr : null,
        });
  };

  // 工具函数   tool_Fnc
  function tool_Fnc(str) {
    //  是否 为 number
    let is_number = (str) => {
      return Object.prototype.toString.call(str) === "[object Number]";
    };
    //  是否为 string
    let is_string = (str) => {
      return Object.prototype.toString.call(str) === "[object String]";
    };
    //  是否为 boolean
    let is_boolean = (str) => {
      return Object.prototype.toString.call(str) === "[object Boolean]";
    };
    //  是否为 object
    let is_object = (str) => {
      return Object.prototype.toString.call(str) === "[object Object]";
    };
    //  是否为 Array
    let is_array = (str) => {
      return Object.prototype.toString.call(str) === "[object Array]";
    };
    // 是否NaN
    let is_NaN = (str) => {
      return isNaN(str);
    };
    //   是否为正则
    let is_regexp = (str) => {
      return Object.prototype.toString.call(str) === "[object RegExp]";
    };

    return {
      is_number,
      is_string,
      is_boolean,
      is_object,
      is_array,
      is_NaN,
      is_regexp,
    };
  }

  return {
    validationData: validationDate_Fnc,
    mobile_Fnc,
    email_Fnc,
    tool_Fnc,
  };
};
// 工具函数   tool_Fnc

export const tool_Fnc = (str) => {
  //  是否 为 number
  let is_number = (str) => {
    return Object.prototype.toString.call(str) === "[object Number]";
  };
  //  是否为 string
  let is_string = (str) => {
    return Object.prototype.toString.call(str) === "[object String]";
  };
  //  是否为 boolean
  let is_boolean = (str) => {
    return Object.prototype.toString.call(str) === "[object Boolean]";
  };
  //  是否为 object
  let is_object = (str) => {
    return Object.prototype.toString.call(str) === "[object Object]";
  };
  //  是否为 Array
  let is_array = (str) => {
    return Object.prototype.toString.call(str) === "[object Array]";
  };
  // 是否NaN
  let is_NaN = (str) => {
    return isNaN(str);
  };
  //   是否为正则
  let is_regexp = (str) => {
    return Object.prototype.toString.call(str) === "[object RegExp]";
  };
  //  是否为 undefind
  let is_undefined = (str) => {
    return Object.prototype.toString.call(str) === "[object Undefined]";
  };
  //  节流防抖 函数
  /**
   * @param  { type Function } throttle 节流 函数
   * @returns   { type  Function  } 需要执行的函数
   */

  return {
    is_number,
    is_string,
    is_boolean,
    is_object,
    is_array,
    is_NaN,
    is_regexp,
  };
};
